home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 1.0 beta / flock-1.0RC3.en-US.win32.exe / flock / components / nsBrowserContentHandler.js < prev    next >
Text File  |  2007-10-18  |  33KB  |  927 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is the Mozilla Firefox browser.
  15.  *
  16.  * The Initial Developer of the Original Code is
  17.  * Benjamin Smedberg <benjamin@smedbergs.us>
  18.  *
  19.  * Portions created by the Initial Developer are Copyright (C) 2004
  20.  * the Initial Developer. All Rights Reserved.
  21.  *
  22.  * Contributor(s):
  23.  *
  24.  * Alternatively, the contents of this file may be used under the terms of
  25.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27.  * in which case the provisions of the GPL or the LGPL are applicable instead
  28.  * of those above. If you wish to allow use of your version of this file only
  29.  * under the terms of either the GPL or the LGPL, and not to allow others to
  30.  * use your version of this file under the terms of the MPL, indicate your
  31.  * decision by deleting the provisions above and replace them with the notice
  32.  * and other provisions required by the GPL or the LGPL. If you do not delete
  33.  * the provisions above, a recipient may use your version of this file under
  34.  * the terms of any one of the MPL, the GPL or the LGPL.
  35.  *
  36.  * ***** END LICENSE BLOCK ***** */
  37.  
  38. const nsISupports            = Components.interfaces.nsISupports;
  39.  
  40. const nsIBrowserDOMWindow    = Components.interfaces.nsIBrowserDOMWindow;
  41. const nsIBrowserHandler      = Components.interfaces.nsIBrowserHandler;
  42. const nsIBrowserHistory      = Components.interfaces.nsIBrowserHistory;
  43. const nsIChannel             = Components.interfaces.nsIChannel;
  44. const nsICommandLine         = Components.interfaces.nsICommandLine;
  45. const nsICommandLineHandler  = Components.interfaces.nsICommandLineHandler;
  46. const nsIContentHandler      = Components.interfaces.nsIContentHandler;
  47. const nsIDocShellTreeItem    = Components.interfaces.nsIDocShellTreeItem;
  48. const nsIDOMChromeWindow     = Components.interfaces.nsIDOMChromeWindow;
  49. const nsIDOMWindow           = Components.interfaces.nsIDOMWindow;
  50. const nsIFactory             = Components.interfaces.nsIFactory;
  51. const nsIFileURL             = Components.interfaces.nsIFileURL;
  52. const nsIJARURI              = Components.interfaces.nsIJARURI;
  53. const nsIHttpProtocolHandler = Components.interfaces.nsIHttpProtocolHandler;
  54. const nsIInterfaceRequestor  = Components.interfaces.nsIInterfaceRequestor;
  55. const nsIPrefBranch          = Components.interfaces.nsIPrefBranch;
  56. const nsIPrefLocalizedString = Components.interfaces.nsIPrefLocalizedString;
  57. const nsISupportsString      = Components.interfaces.nsISupportsString;
  58. const nsIURIFixup            = Components.interfaces.nsIURIFixup;
  59. const nsIWebNavigation       = Components.interfaces.nsIWebNavigation;
  60. const nsIWindowMediator      = Components.interfaces.nsIWindowMediator;
  61. const nsIWindowWatcher       = Components.interfaces.nsIWindowWatcher;
  62. const nsICategoryManager     = Components.interfaces.nsICategoryManager;
  63. const nsIWebNavigationInfo   = Components.interfaces.nsIWebNavigationInfo;
  64. const nsIBrowserSearchService = Components.interfaces.nsIBrowserSearchService;
  65. const nsICommandLineValidator = Components.interfaces.nsICommandLineValidator;
  66.  
  67. const NS_BINDING_ABORTED = 0x804b0002;
  68. const NS_ERROR_WONT_HANDLE_CONTENT = 0x805d0001;
  69. const NS_ERROR_ABORT = Components.results.NS_ERROR_ABORT;
  70.  
  71. function shouldLoadURI(aURI) {
  72.   if (aURI && !aURI.schemeIs("chrome"))
  73.     return true;
  74.  
  75.   dump("*** Preventing external load of chrome: URI into browser window\n");
  76.   dump("    Use -chrome <uri> instead\n");
  77.   return false;
  78. }
  79.  
  80. function resolveURIInternal(aCmdLine, aArgument) {
  81.   var uri = aCmdLine.resolveURI(aArgument);
  82.  
  83.   if (!(uri instanceof nsIFileURL)) {
  84.     return uri;
  85.   }
  86.  
  87.   try {
  88.     if (uri.file.exists())
  89.       return uri;
  90.   }
  91.   catch (e) {
  92.     Components.utils.reportError(e);
  93.   }
  94.  
  95.   // We have interpreted the argument as a relative file URI, but the file
  96.   // doesn't exist. Try URI fixup heuristics: see bug 290782.
  97.  
  98.   try {
  99.     var urifixup = Components.classes["@mozilla.org/docshell/urifixup;1"]
  100.                              .getService(nsIURIFixup);
  101.  
  102.     uri = urifixup.createFixupURI(aArgument, 0);
  103.   }
  104.   catch (e) {
  105.     Components.utils.reportError(e);
  106.   }
  107.  
  108.   return uri;
  109. }
  110.  
  111. const OVERRIDE_NONE        = 0;
  112. const OVERRIDE_NEW_PROFILE = 1;
  113. const OVERRIDE_NEW_MSTONE  = 2;
  114. /**
  115.  * Determines whether a home page override is needed.
  116.  * Returns:
  117.  *  OVERRIDE_NEW_PROFILE if this is the first run with a new profile.
  118.  *  OVERRIDE_NEW_MSTONE if this is the first run with a build with a different
  119.  *                      Gecko milestone (i.e. right after an upgrade).
  120.  *  OVERRIDE_NONE otherwise.
  121.  */
  122. function needHomepageOverride(prefb) {
  123.   var savedmstone = null;
  124.   try {
  125.     savedmstone = prefb.getCharPref("browser.startup.homepage_override.mstone");
  126.   } catch (e) {}
  127.  
  128.   var savedVersion = null;
  129.   try {
  130.     savedVersion = prefb.getCharPref("browser.startup.homepage_override.appVersion");
  131.   }
  132.   catch (e) {
  133.   }
  134.  
  135.   if (savedmstone == "ignore" || savedVersion == "ignore")
  136.     return OVERRIDE_NONE;
  137.  
  138.   var appVersion = Components.classes["@mozilla.org/xre/app-info;1"]
  139.                              .getService(Components.interfaces.nsIXULAppInfo)
  140.                              .version;
  141.    
  142.   var mstone = Components.classes["@mozilla.org/network/protocol;1?name=http"]
  143.                          .getService(nsIHttpProtocolHandler).misc;
  144.  
  145.   if (appVersion != savedVersion) {
  146.     prefb.setCharPref("browser.startup.homepage_override.appVersion", appVersion);
  147.     // We save this for compatibility with Firefox
  148.     prefb.setCharPref("browser.startup.homepage_override.mstone",      mstone);
  149.     return ((savedmstone || savedVersion) ? OVERRIDE_NEW_MSTONE
  150.                                           : OVERRIDE_NEW_PROFILE);
  151.   }
  152.  
  153.   return OVERRIDE_NONE;
  154. }
  155.  
  156. // Copies a pref override file into the user's profile pref-override folder,
  157. // and then tells the pref service to reload it's default prefs.
  158. function copyPrefOverride() {
  159.   try {
  160.     var fileLocator = Components.classes["@mozilla.org/file/directory_service;1"]
  161.                                 .getService(Components.interfaces.nsIProperties);
  162.     const NS_APP_EXISTING_PREF_OVERRIDE = "ExistingPrefOverride";
  163.     var prefOverride = fileLocator.get(NS_APP_EXISTING_PREF_OVERRIDE,
  164.                                        Components.interfaces.nsIFile);
  165.     if (!prefOverride.exists())
  166.       return; // nothing to do
  167.  
  168.     const NS_APP_PREFS_OVERRIDE_DIR     = "PrefDOverride";
  169.     var prefOverridesDir = fileLocator.get(NS_APP_PREFS_OVERRIDE_DIR,
  170.                                            Components.interfaces.nsIFile);
  171.  
  172.     // Check for any existing pref overrides, and remove them if present
  173.     var existingPrefOverridesFile = prefOverridesDir.clone();
  174.     existingPrefOverridesFile.append(prefOverride.leafName);
  175.     if (existingPrefOverridesFile.exists())
  176.       existingPrefOverridesFile.remove(false);
  177.  
  178.     prefOverride.copyTo(prefOverridesDir, null);
  179.  
  180.     // Now that we've installed the new-profile pref override file,
  181.     // re-read the default prefs.
  182.     var prefSvcObs = Components.classes["@mozilla.org/preferences-service;1"]
  183.                                .getService(Components.interfaces.nsIObserver);
  184.     prefSvcObs.observe(null, "reload-default-prefs", null);
  185.   } catch (ex) {
  186.     Components.utils.reportError(ex);
  187.   }
  188. }
  189.  
  190. function openWindow(parent, url, target, features, args) {
  191.   var wwatch = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
  192.                          .getService(nsIWindowWatcher);
  193.  
  194.   var argstring;
  195.   if (args) {
  196.     argstring = Components.classes["@mozilla.org/supports-string;1"]
  197.                             .createInstance(nsISupportsString);
  198.     argstring.data = args;
  199.   }
  200.   return wwatch.openWindow(parent, url, target, features, argstring);
  201. }
  202.  
  203. function openPreferences() {
  204.   var features = "chrome,titlebar,toolbar,centerscreen,dialog=no";
  205.   var url = "chrome://browser/content/preferences/preferences.xul";
  206.  
  207.   var win = getMostRecentWindow("Browser:Preferences");
  208.   if (win) {
  209.     win.focus();
  210.   } else {
  211.     openWindow(null, url, "_blank", features);
  212.   }
  213. }
  214.  
  215. function getMostRecentWindow(aType) {
  216.   var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
  217.                      .getService(nsIWindowMediator);
  218.   return wm.getMostRecentWindow(aType);
  219. }
  220.  
  221. //@line 229 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/nsBrowserContentHandler.js"
  222.  
  223. // this returns the most recent non-popup browser window
  224. function getMostRecentBrowserWindow() {
  225.   var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"]
  226.                      .getService(Components.interfaces.nsIWindowMediator);
  227.  
  228. //@line 249 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/nsBrowserContentHandler.js"
  229.   var windowList = wm.getZOrderDOMWindowEnumerator("navigator:browser", true);
  230.   if (!windowList.hasMoreElements())
  231.     return null;
  232.  
  233.   var win = windowList.getNext();
  234.   while (!win.toolbar.visible) {
  235.     if (!windowList.hasMoreElements()) 
  236.       return null;
  237.  
  238.     win = windowList.getNext();
  239.   }
  240. //@line 261 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/nsBrowserContentHandler.js"
  241.  
  242.   return win;
  243. }
  244.  
  245. function doSearch(searchTerm, cmdLine) {
  246.   var ss = Components.classes["@mozilla.org/browser/search-service;1"]
  247.                      .getService(nsIBrowserSearchService);
  248.  
  249.   var submission = ss.defaultEngine.getSubmission(searchTerm, null);
  250.  
  251.   // fill our nsISupportsArray with uri-as-wstring, null, null, postData
  252.   var sa = Components.classes["@mozilla.org/supports-array;1"]
  253.                      .createInstance(Components.interfaces.nsISupportsArray);
  254.  
  255.   var wuri = Components.classes["@mozilla.org/supports-string;1"]
  256.                        .createInstance(Components.interfaces.nsISupportsString);
  257.   wuri.data = submission.uri.spec;
  258.  
  259.   sa.AppendElement(wuri);
  260.   sa.AppendElement(null);
  261.   sa.AppendElement(null);
  262.   sa.AppendElement(submission.postData);
  263.  
  264.   // XXXbsmedberg: use handURIToExistingBrowser to obey tabbed-browsing
  265.   // preferences, but need nsIBrowserDOMWindow extensions
  266.  
  267.   var wwatch = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
  268.                          .getService(nsIWindowWatcher);
  269.  
  270.   return wwatch.openWindow(null, nsBrowserContentHandler.chromeURL,
  271.                            "_blank",
  272.                            "chrome,dialog=no,all" +
  273.                              nsBrowserContentHandler.getFeatures(cmdLine),
  274.                            sa);
  275. }
  276.  
  277. var nsBrowserContentHandler = {
  278.   /* helper functions */
  279.  
  280.   mChromeURL : null,
  281.  
  282.   get chromeURL() {
  283.     if (this.mChromeURL) {
  284.       return this.mChromeURL;
  285.     }
  286.  
  287.     var prefb = Components.classes["@mozilla.org/preferences-service;1"]
  288.                           .getService(nsIPrefBranch);
  289.     this.mChromeURL = prefb.getCharPref("browser.chromeURL");
  290.  
  291.     return this.mChromeURL;
  292.   },
  293.  
  294.   /* nsISupports */
  295.   QueryInterface : function bch_QI(iid) {
  296.     if (!iid.equals(nsISupports) &&
  297.         !iid.equals(nsICommandLineHandler) &&
  298.         !iid.equals(nsIBrowserHandler) &&
  299.         !iid.equals(nsIContentHandler) &&
  300.         !iid.equals(nsICommandLineValidator) &&
  301.         !iid.equals(nsIFactory))
  302.       throw Components.errors.NS_ERROR_NO_INTERFACE;
  303.  
  304.     return this;
  305.   },
  306.  
  307.   /* nsICommandLineHandler */
  308.   handle : function bch_handle(cmdLine) {
  309.     if (cmdLine.handleFlag("browser", false)) {
  310.       openWindow(null, this.chromeURL, "_blank",
  311.                  "chrome,dialog=no,all" + this.getFeatures(cmdLine),
  312.                  this.defaultArgs);
  313.       cmdLine.preventDefault = true;
  314.     }
  315.  
  316.     try {
  317.       var remoteCommand = cmdLine.handleFlagWithParam("remote", true);
  318.     }
  319.     catch (e) {
  320.       throw NS_ERROR_ABORT;
  321.     }
  322.  
  323.     if (remoteCommand != null) {
  324.       try {
  325.         var a = /^\s*(\w+)\(([^\)]*)\)\s*$/.exec(remoteCommand);
  326.         var remoteVerb;
  327.         if (a) {
  328.           remoteVerb = a[1].toLowerCase();
  329.           var remoteParams = [];
  330.           var sepIndex = a[2].lastIndexOf(",");
  331.           if (sepIndex == -1)
  332.             remoteParams[0] = a[2];
  333.           else {
  334.             remoteParams[0] = a[2].substring(0, sepIndex);
  335.             remoteParams[1] = a[2].substring(sepIndex + 1);
  336.           }
  337.         }
  338.  
  339.         switch (remoteVerb) {
  340.         case "openurl":
  341.         case "openfile":
  342.           // openURL(<url>)
  343.           // openURL(<url>,new-window)
  344.           // openURL(<url>,new-tab)
  345.  
  346.           // First param is the URL, second param (if present) is the "target"
  347.           // (tab, window)
  348.           var url = remoteParams[0];
  349.           var target = nsIBrowserDOMWindow.OPEN_DEFAULTWINDOW;
  350.           if (remoteParams[1]) {
  351.             var targetParam = remoteParams[1].toLowerCase()
  352.                                              .replace(/^\s*|\s*$/g, "");
  353.             if (targetParam == "new-tab")
  354.               target = nsIBrowserDOMWindow.OPEN_NEWTAB;
  355.             else if (targetParam == "new-window")
  356.               target = nsIBrowserDOMWindow.OPEN_NEWWINDOW;
  357.             else {
  358.               // The "target" param isn't one of our supported values, so
  359.               // assume it's part of a URL that contains commas.
  360.               url += "," + remoteParams[1];
  361.             }
  362.           }
  363.  
  364.           var uri = resolveURIInternal(cmdLine, url);
  365.           handURIToExistingBrowser(uri, target, cmdLine);
  366.           break;
  367.  
  368.         case "xfedocommand":
  369.           // xfeDoCommand(openBrowser)
  370.           if (remoteParams[0].toLowerCase() != "openbrowser")
  371.             throw NS_ERROR_ABORT;
  372.  
  373.           openWindow(null, this.chromeURL, "_blank",
  374.                      "chrome,dialog=no,all" + this.getFeatures(cmdLine),
  375.                      this.defaultArgs);
  376.           break;
  377.  
  378.         default:
  379.           // Somebody sent us a remote command we don't know how to process:
  380.           // just abort.
  381.           throw "Unknown remote command.";
  382.         }
  383.  
  384.         cmdLine.preventDefault = true;
  385.       }
  386.       catch (e) {
  387.         Components.utils.reportError(e);
  388.         // If we had a -remote flag but failed to process it, throw
  389.         // NS_ERROR_ABORT so that the xremote code knows to return a failure
  390.         // back to the handling code.
  391.         throw NS_ERROR_ABORT;
  392.       }
  393.     }
  394.  
  395.     var uriparam;
  396.     try {
  397.       while ((uriparam = cmdLine.handleFlagWithParam("new-window", false))) {
  398.         var uri = resolveURIInternal(cmdLine, uriparam);
  399.         if (!shouldLoadURI(uri))
  400.           continue;
  401.         openWindow(null, this.chromeURL, "_blank",
  402.                    "chrome,dialog=no,all" + this.getFeatures(cmdLine),
  403.                    uri.spec);
  404.         cmdLine.preventDefault = true;
  405.       }
  406.     }
  407.     catch (e) {
  408.       Components.utils.reportError(e);
  409.     }
  410.  
  411.     try {
  412.       while ((uriparam = cmdLine.handleFlagWithParam("new-tab", false))) {
  413.         var uri = resolveURIInternal(cmdLine, uriparam);
  414.         handURIToExistingBrowser(uri, nsIBrowserDOMWindow.OPEN_NEWTAB, cmdLine);
  415.         cmdLine.preventDefault = true;
  416.       }
  417.     }
  418.     catch (e) {
  419.       Components.utils.reportError(e);
  420.     }
  421.  
  422.     var chromeParam = cmdLine.handleFlagWithParam("chrome", false);
  423.     if (chromeParam) {
  424.  
  425.       // Handle the old preference dialog URL separately (bug 285416)
  426.       if (chromeParam == "chrome://browser/content/pref/pref.xul") {
  427.         openPreferences();
  428.         cmdLine.preventDefault = true;
  429.       } else try {
  430.         // only load URIs which do not inherit chrome privs.
  431.  
  432.         // normally would call checkLoadURI(..., DISALLOW_SCRIPT_OR_DATA)
  433.         // for this, but in this context we crash when the security manager
  434.         // tries to throw an exception (no window object here). On the branch
  435.         // we need to simulate the important bits
  436.         var uri = resolveURIInternal(cmdLine, chromeParam);
  437.         while (uri instanceof nsIJARURI) {
  438.           // unpack to find the real scheme
  439.           uri = uri.JARFile;
  440.         }
  441.         if (!uri.schemeIs("javascript") && !uri.schemeIs("data")) {
  442.           var features = "chrome,dialog=no,all" + this.getFeatures(cmdLine);
  443.           openWindow(null, uri.spec, "_blank", features, "");
  444.           cmdLine.preventDefault = true;
  445.         }
  446.       }
  447.       catch (e) {
  448.         Components.utils.reportError(e);
  449.       }
  450.     }
  451.     if (cmdLine.handleFlag("preferences", false)) {
  452.       openPreferences();
  453.       cmdLine.preventDefault = true;
  454.     }
  455.     if (cmdLine.handleFlag("silent", false))
  456.       cmdLine.preventDefault = true;
  457.  
  458.     var searchParam = cmdLine.handleFlagWithParam("search", false);
  459.     if (searchParam) {
  460.       doSearch(searchParam, cmdLine);
  461.       cmdLine.preventDefault = true;
  462.     }
  463.  
  464. //@line 485 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/nsBrowserContentHandler.js"
  465.     // Handle "? searchterm" for Windows Vista start menu integration
  466.     for (var i = cmdLine.length - 1; i >= 0; --i) {
  467.       var param = cmdLine.getArgument(i);
  468.       if (param.match(/^\? /)) {
  469.         cmdLine.removeArguments(i, i);
  470.         cmdLine.preventDefault = true;
  471.  
  472.         searchParam = param.substr(2);
  473.         doSearch(searchParam, cmdLine);
  474.       }
  475.     }
  476. //@line 497 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/nsBrowserContentHandler.js"
  477.   },
  478.  
  479.   helpInfo : "  -browser            Open a browser window.\n",
  480.  
  481.   /* nsIBrowserHandler */
  482.  
  483.   get defaultArgs() {
  484.     var prefb = Components.classes["@mozilla.org/preferences-service;1"]
  485.                           .getService(nsIPrefBranch);
  486.     var formatter = Components.classes["@mozilla.org/toolkit/URLFormatterService;1"]
  487.                               .getService(Components.interfaces.nsIURLFormatter);
  488.  
  489.     var overridePage = "";
  490.     var haveUpdateSession = false;
  491.     try {
  492.       switch (needHomepageOverride(prefb)) {
  493.         case OVERRIDE_NEW_PROFILE:
  494.           // New profile.
  495.           overridePage = formatter.formatURLPref("startup.homepage_welcome_url");
  496.           break;
  497.         case OVERRIDE_NEW_MSTONE:
  498.           // Existing profile.
  499.           copyPrefOverride();
  500.  
  501.           // Check whether we have a session to restore. If we do, we assume
  502.           // that this is an "update" session.
  503.           var ss = Components.classes["@mozilla.org/browser/sessionstartup;1"]
  504.                              .getService(Components.interfaces.nsISessionStartup);
  505.           haveUpdateSession = ss.doRestore();
  506.           overridePage = formatter.formatURLPref("startup.homepage_override_url");
  507.           break;
  508.       }
  509.     } catch (e) {}
  510.  
  511.     // formatURLPref might return "about:blank" if getting the pref fails
  512.     if (overridePage == "about:blank")
  513.       overridePage = "";
  514.  
  515.     var startPage = "";
  516.     try {
  517.       var choice = prefb.getIntPref("browser.startup.page");
  518.       if (choice == 1)
  519.         startPage = this.startPage;
  520.  
  521.       if (choice == 2)
  522.         startPage = Components.classes["@mozilla.org/browser/global-history;2"]
  523.                               .getService(nsIBrowserHistory).lastPageVisited;
  524.     } catch (e) {
  525.       Components.utils.reportError(e);
  526.     }
  527.  
  528.     if (startPage == "about:blank")
  529.       startPage = "";
  530.  
  531.     // Only show the startPage if we're not restoring an update session.
  532.     if (overridePage && startPage && !haveUpdateSession)
  533.       return overridePage + "|" + startPage;
  534.  
  535.     return overridePage || startPage || "about:blank";
  536.   },
  537.  
  538.   get startPage() {
  539.     var prefb = Components.classes["@mozilla.org/preferences-service;1"]
  540.                           .getService(nsIPrefBranch);
  541.  
  542.     var uri = prefb.getComplexValue("browser.startup.homepage",
  543.                                     nsIPrefLocalizedString).data;
  544.  
  545.     if (!uri) {
  546.       prefb.clearUserPref("browser.startup.homepage");
  547.       uri = prefb.getComplexValue("browser.startup.homepage",
  548.                                   nsIPrefLocalizedString).data;
  549.     }
  550.                                 
  551.     var count;
  552.     try {
  553.       count = prefb.getIntPref("browser.startup.homepage.count");
  554.     }
  555.     catch (e) {
  556.       return uri;
  557.     }
  558.  
  559.     for (var i = 1; i < count; ++i) {
  560.       try {
  561.         var page = prefb.getComplexValue("browser.startup.homepage." + i,
  562.                                          nsIPrefLocalizedString).data;
  563.         uri += "\n" + page;
  564.       }
  565.       catch (e) {
  566.       }
  567.     }
  568.  
  569.     return uri;
  570.   },
  571.  
  572.   mFeatures : null,
  573.  
  574.   getFeatures : function bch_features(cmdLine) {
  575.     if (this.mFeatures === null) {
  576.       this.mFeatures = "";
  577.  
  578.       try {
  579.         var width = cmdLine.handleFlagWithParam("width", false);
  580.         var height = cmdLine.handleFlagWithParam("height", false);
  581.  
  582.         if (width)
  583.           this.mFeatures += ",width=" + width;
  584.         if (height)
  585.           this.mFeatures += ",height=" + height;
  586.       }
  587.       catch (e) {
  588.       }
  589.     }
  590.  
  591.     return this.mFeatures;
  592.   },
  593.  
  594.   /* nsIContentHandler */
  595.  
  596.   handleContent : function bch_handleContent(contentType, context, request) {
  597.     try {
  598.       var webNavInfo = Components.classes["@mozilla.org/webnavigation-info;1"]
  599.                                  .getService(nsIWebNavigationInfo);
  600.       if (!webNavInfo.isTypeSupported(contentType, null)) {
  601.         throw NS_ERROR_WONT_HANDLE_CONTENT;
  602.       }
  603.     } catch (e) {
  604.       throw NS_ERROR_WONT_HANDLE_CONTENT;
  605.     }
  606.  
  607.     var parentWin;
  608.     try {
  609.       parentWin = context.getInterface(nsIDOMWindow);
  610.     }
  611.     catch (e) {
  612.     }
  613.  
  614.     request.QueryInterface(nsIChannel);
  615.     
  616.     openWindow(parentWin, request.URI, "_blank", null, null);
  617.     request.cancel(NS_BINDING_ABORTED);
  618.   },
  619.  
  620.   /* nsICommandLineValidator */
  621.   validate : function bch_validate(cmdLine) {
  622.     // Other handlers may use osint so only handle the osint flag if the url
  623.     // flag is also present and the command line is valid.
  624.     var osintFlagIdx = cmdLine.findFlag("osint", false);
  625.     var urlFlagIdx = cmdLine.findFlag("url", false);
  626.     if (urlFlagIdx > -1 && (osintFlagIdx > -1 ||
  627.         cmdLine.state == nsICommandLine.STATE_REMOTE_EXPLICIT)) {
  628.       var urlParam = cmdLine.getArgument(urlFlagIdx + 1);
  629.       if (cmdLine.length != urlFlagIdx + 2 || /firefoxurl:/.test(urlParam))
  630.         throw NS_ERROR_ABORT;
  631.       cmdLine.handleFlag("osint", false)
  632.     }
  633.   },
  634.  
  635.   /* nsIFactory */
  636.   createInstance: function bch_CI(outer, iid) {
  637.     if (outer != null)
  638.       throw Components.results.NS_ERROR_NO_AGGREGATION;
  639.  
  640.     return this.QueryInterface(iid);
  641.   },
  642.     
  643.   lockFactory : function bch_lock(lock) {
  644.     /* no-op */
  645.   }
  646. };
  647.  
  648. const bch_contractID = "@mozilla.org/browser/clh;1";
  649. const bch_CID = Components.ID("{5d0ce354-df01-421a-83fb-7ead0990c24e}");
  650. const CONTRACTID_PREFIX = "@mozilla.org/uriloader/content-handler;1?type=";
  651.  
  652. function handURIToExistingBrowser(uri, location, cmdLine)
  653. {
  654.   if (!shouldLoadURI(uri))
  655.     return;
  656.  
  657.   var navWin = getMostRecentBrowserWindow();
  658.   if (!navWin) {
  659.     // if we couldn't load it in an existing window, open a new one
  660.     openWindow(null, nsBrowserContentHandler.chromeURL, "_blank",
  661.                "chrome,dialog=no,all" + nsBrowserContentHandler.getFeatures(cmdLine),
  662.                uri.spec);
  663.     return;
  664.   }
  665.  
  666.   var navNav = navWin.QueryInterface(nsIInterfaceRequestor)
  667.                      .getInterface(nsIWebNavigation);
  668.   var rootItem = navNav.QueryInterface(nsIDocShellTreeItem).rootTreeItem;
  669.   var rootWin = rootItem.QueryInterface(nsIInterfaceRequestor)
  670.                         .getInterface(nsIDOMWindow);
  671.   var bwin = rootWin.QueryInterface(nsIDOMChromeWindow).browserDOMWindow;
  672.   bwin.openURI(uri, null, location,
  673.                nsIBrowserDOMWindow.OPEN_EXTERNAL);
  674. }
  675.  
  676.  
  677. var nsDefaultCommandLineHandler = {
  678.   /* nsISupports */
  679.   QueryInterface : function dch_QI(iid) {
  680.     if (!iid.equals(nsISupports) &&
  681.         !iid.equals(nsICommandLineHandler) &&
  682.         !iid.equals(nsIFactory))
  683.       throw Components.errors.NS_ERROR_NO_INTERFACE;
  684.  
  685.     return this;
  686.   },
  687.  
  688.   // List of uri's that were passed via the command line without the app
  689.   // running and have already been handled. This is compared against uri's
  690.   // opened using DDE on Win32 so we only open one of the requests.
  691.   _handledURIs: [ ],
  692. //@line 713 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/nsBrowserContentHandler.js"
  693.   _haveProfile: false,
  694. //@line 715 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/nsBrowserContentHandler.js"
  695.  
  696.   /* nsICommandLineHandler */
  697.   handle : function dch_handle(cmdLine) {
  698.     var urilist = [];
  699.  
  700. //@line 721 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/nsBrowserContentHandler.js"
  701.     // If we don't have a profile selected yet (e.g. the Profile Manager is
  702.     // displayed) we will crash if we open an url and then select a profile. To
  703.     // prevent this handle all url command line flags and set the command line's
  704.     // preventDefault to true to prevent the display of the ui. The initial
  705.     // command line will be retained when nsAppRunner calls LaunchChild though
  706.     // urls launched after the initial launch will be lost.
  707.     if (!this._haveProfile) {
  708.       try {
  709.         // This will throw when a profile has not been selected.
  710.         var fl = Components.classes["@mozilla.org/file/directory_service;1"]
  711.                            .getService(Components.interfaces.nsIProperties);
  712.         var dir = fl.get("ProfD", Components.interfaces.nsILocalFile);
  713.         this._haveProfile = true;
  714.       }
  715.       catch (e) {
  716.         while ((ar = cmdLine.handleFlagWithParam("url", false))) { }
  717.         cmdLine.preventDefault = true;
  718.       }
  719.     }
  720. //@line 741 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/nsBrowserContentHandler.js"
  721.  
  722.     try {
  723.       var ar;
  724.       while ((ar = cmdLine.handleFlagWithParam("url", false))) {
  725.         var found = false;
  726.         var uri = resolveURIInternal(cmdLine, ar);
  727.         // count will never be greater than zero except on Win32.
  728.         var count = this._handledURIs.length;
  729.         for (var i = 0; i < count; ++i) {
  730.           if (this._handledURIs[i].spec == uri.spec) {
  731.             this._handledURIs.splice(i, 1);
  732.             found = true;
  733.             cmdLine.preventDefault = true;
  734.             break;
  735.           }
  736.         }
  737.         if (!found) {
  738.           urilist.push(uri);
  739.           // The requestpending command line flag is only used on Win32.
  740.           if (cmdLine.handleFlag("requestpending", false) &&
  741.               cmdLine.state == nsICommandLine.STATE_INITIAL_LAUNCH)
  742.             this._handledURIs.push(uri)
  743.         }
  744.       }
  745.     }
  746.     catch (e) {
  747.       Components.utils.reportError(e);
  748.     }
  749.  
  750.     count = cmdLine.length;
  751.  
  752.     for (i = 0; i < count; ++i) {
  753.       var curarg = cmdLine.getArgument(i);
  754.       if (curarg.match(/^-/)) {
  755.         Components.utils.reportError("Warning: unrecognized command line flag " + curarg + "\n");
  756.         // To emulate the pre-nsICommandLine behavior, we ignore
  757.         // the argument after an unrecognized flag.
  758.         ++i;
  759.       } else {
  760.         try {
  761.           urilist.push(resolveURIInternal(cmdLine, curarg));
  762.         }
  763.         catch (e) {
  764.           Components.utils.reportError("Error opening URI '" + curarg + "' from the command line: " + e + "\n");
  765.         }
  766.       }
  767.     }
  768.  
  769.     if (urilist.length) {
  770.       if (cmdLine.state != nsICommandLine.STATE_INITIAL_LAUNCH &&
  771.           urilist.length == 1) {
  772.         // Try to find an existing window and load our URI into the
  773.         // current tab, new tab, or new window as prefs determine.
  774.         try {
  775.           handURIToExistingBrowser(urilist[0], nsIBrowserDOMWindow.OPEN_DEFAULTWINDOW, cmdLine);
  776.           return;
  777.         }
  778.         catch (e) {
  779.         }
  780.       }
  781.  
  782.       var speclist = [];
  783.       for (uri in urilist) {
  784.         if (shouldLoadURI(urilist[uri]))
  785.           speclist.push(urilist[uri].spec);
  786.       }
  787.  
  788.       if (speclist.length) {
  789.         openWindow(null, nsBrowserContentHandler.chromeURL, "_blank",
  790.                    "chrome,dialog=no,all" + nsBrowserContentHandler.getFeatures(cmdLine),
  791.                    speclist.join("|"));
  792.       }
  793.  
  794.     }
  795.     else if (!cmdLine.preventDefault) {
  796.       openWindow(null, nsBrowserContentHandler.chromeURL, "_blank",
  797.                  "chrome,dialog=no,all" + nsBrowserContentHandler.getFeatures(cmdLine),
  798.                  nsBrowserContentHandler.defaultArgs);
  799.     }
  800.   },
  801.  
  802.   // XXX localize me... how?
  803.   helpInfo : "Usage: firefox [-flags] [<url>]\n",
  804.  
  805.   /* nsIFactory */
  806.   createInstance: function dch_CI(outer, iid) {
  807.     if (outer != null)
  808.       throw Components.results.NS_ERROR_NO_AGGREGATION;
  809.  
  810.     return this.QueryInterface(iid);
  811.   },
  812.     
  813.   lockFactory : function dch_lock(lock) {
  814.     /* no-op */
  815.   }
  816. };
  817.  
  818. const dch_contractID = "@mozilla.org/browser/final-clh;1";
  819. const dch_CID = Components.ID("{47cd0651-b1be-4a0f-b5c4-10e5a573ef71}");
  820.  
  821. var Module = {
  822.   /* nsISupports */
  823.   QueryInterface: function mod_QI(iid) {
  824.     if (iid.equals(Components.interfaces.nsIModule) ||
  825.         iid.equals(Components.interfaces.nsISupports))
  826.       return this;
  827.  
  828.     throw Components.results.NS_ERROR_NO_INTERFACE;
  829.   },
  830.  
  831.   /* nsIModule */
  832.   getClassObject: function mod_getco(compMgr, cid, iid) {
  833.     if (cid.equals(bch_CID))
  834.       return nsBrowserContentHandler.QueryInterface(iid);
  835.  
  836.     if (cid.equals(dch_CID))
  837.       return nsDefaultCommandLineHandler.QueryInterface(iid);
  838.  
  839.     throw Components.results.NS_ERROR_NO_INTERFACE;
  840.   },
  841.     
  842.   registerSelf: function mod_regself(compMgr, fileSpec, location, type) {
  843.     var compReg =
  844.       compMgr.QueryInterface( Components.interfaces.nsIComponentRegistrar );
  845.  
  846.     compReg.registerFactoryLocation( bch_CID,
  847.                                      "nsBrowserContentHandler",
  848.                                      bch_contractID,
  849.                                      fileSpec,
  850.                                      location,
  851.                                      type );
  852.     compReg.registerFactoryLocation( dch_CID,
  853.                                      "nsDefaultCommandLineHandler",
  854.                                      dch_contractID,
  855.                                      fileSpec,
  856.                                      location,
  857.                                      type );
  858.  
  859.     function registerType(contentType) {
  860.       compReg.registerFactoryLocation( bch_CID,
  861.                                        "Browser Cmdline Handler",
  862.                                        CONTRACTID_PREFIX + contentType,
  863.                                        fileSpec,
  864.                                        location,
  865.                                        type );
  866.     }
  867.  
  868.     registerType("text/html");
  869.     registerType("application/vnd.mozilla.xul+xml");
  870. //@line 891 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/nsBrowserContentHandler.js"
  871.     registerType("image/svg+xml");
  872. //@line 893 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/nsBrowserContentHandler.js"
  873.     registerType("text/rdf");
  874.     registerType("text/xml");
  875.     registerType("application/xhtml+xml");
  876.     registerType("text/css");
  877.     registerType("text/plain");
  878.     registerType("image/gif");
  879.     registerType("image/jpeg");
  880.     registerType("image/jpg");
  881.     registerType("image/png");
  882.     registerType("image/bmp");
  883.     registerType("image/x-icon");
  884.     registerType("image/vnd.microsoft.icon");
  885.     registerType("image/x-xbitmap");
  886.     registerType("application/http-index-format");
  887.  
  888.     var catMan = Components.classes["@mozilla.org/categorymanager;1"]
  889.                            .getService(nsICategoryManager);
  890.  
  891.     catMan.addCategoryEntry("command-line-handler",
  892.                             "m-browser",
  893.                             bch_contractID, true, true);
  894.     catMan.addCategoryEntry("command-line-handler",
  895.                             "x-default",
  896.                             dch_contractID, true, true);
  897.     catMan.addCategoryEntry("command-line-validator",
  898.                             "b-browser",
  899.                             bch_contractID, true, true);
  900.   },
  901.     
  902.   unregisterSelf : function mod_unregself(compMgr, location, type) {
  903.     var compReg = compMgr.QueryInterface(nsIComponentRegistrar);
  904.     compReg.unregisterFactoryLocation(bch_CID, location);
  905.     compReg.unregisterFactoryLocation(dch_CID, location);
  906.  
  907.     var catMan = Components.classes["@mozilla.org/categorymanager;1"]
  908.                            .getService(nsICategoryManager);
  909.  
  910.     catMan.deleteCategoryEntry("command-line-handler",
  911.                                "m-browser", true);
  912.     catMan.deleteCategoryEntry("command-line-handler",
  913.                                "x-default", true);
  914.     catMan.deleteCategoryEntry("command-line-validator",
  915.                                "b-browser", true);
  916.   },
  917.  
  918.   canUnload: function(compMgr) {
  919.     return true;
  920.   }
  921. };
  922.  
  923. // NSGetModule: Return the nsIModule object.
  924. function NSGetModule(compMgr, fileSpec) {
  925.   return Module;
  926. }
  927.